#include "Timer.h"

using namespace TP;
using namespace TP::Threading;
using namespace TP::Temporizador;

Timer::Timer() {
    _modo = RELOJ;
    _tiempoLimite = _tiempoActual = 0;
}

Timer::Timer(const tiempo_t &segundos, const timer_modo_t &modo) {
    _modo = modo;
    _tiempoLimite = segundos;
}

Timer::~Timer() {
    Finalizar();
}

void Timer::setTiempo(const tiempo_t &segundos) {
    _tiempoLimite = segundos;
}

void Timer::setModo(const timer_modo_t &modo) {
    _modo = modo;
}

void Timer::tarea() {
    time(&_ti);
    _encendido = true;
    while(_encendido) {
        if(__comparar()) {
            time (&_tf);
            if(difftime(_tf,_ti) > salto_tiempo) {
                _tiempoActual += _deltaTiempo;         
                time(&_ti);   
            }    
        }
    }
}


bool Timer::timeOut() const {
    bool res;
    
    switch(_modo) {
        case ASCENDENTE: res = (_tiempoLimite == _tiempoActual); break;
        case DESCENDENTE: res = (!_tiempoActual); break;
        default: res = 0;
    }
    return res;
}

void Timer::prender() {
    /*switch(_modo) {
        case ASCENDENTE: this->fComp = (Timer::__compAscendente()); break;
        case DESCENDENTE: this->fComp = __compDescendente(); break;
        default: this->fComp = __compReloj(); break;
    }*/
    _tiempoActual = (_modo == DESCENDENTE) ? _tiempoLimite : 0;
    _deltaTiempo = (_modo == DESCENDENTE) ? (salto_tiempo*(-1)) : salto_tiempo;
}

void Timer::apagar() {
    _encendido = false;
    Finalizar();
}

void Timer::resetear() {
    if(_modo == ASCENDENTE || _modo == RELOJ)
        _tiempoActual = 0;
    else if (_modo == DESCENDENTE)
        _tiempoActual = _tiempoLimite;
     time(&_ti);
}

tiempo_t Timer::getTiempo() {
    return _tiempoActual;
}

    
bool Timer::__compAscendente() {
    return (_tiempoActual < _tiempoLimite);
}
    
bool Timer::__compDescendente() {
    return (_tiempoActual > 0);
}
    
bool Timer::__compReloj() {
    return true;
}
    
bool Timer::__comparar() {
    bool resComp;
    
    switch(_modo) {
        case ASCENDENTE: resComp = __compAscendente(); break;
        case DESCENDENTE: resComp = __compDescendente(); break;
        default: resComp = __compReloj(); break;
    }
    
    return resComp;
}